package com.hitrust.gs.business;

import java.sql.Connection;
import java.util.ArrayList;

import system.LoginContext;
import system.base.User;

import com.hitrust.gs.bean.GSProviderBean;
import com.hitrust.gs.dao.GSProductTypeDao;
import com.hitrust.gs.dao.GSProviderDAO;
import com.hitrust.gs.lib.GSBaseConstants;
import com.hitrust.gs.lib.GSLogWriter;
import com.hitrust.gs.lib.db.DBConnectionManager;
import com.hitrust.gs.util.exception.GSException;
import com.hitrust.gs.util.page.ResultProcess;

import framework.core.ConstDefine;

/**
 * 
 */
public class GSProviderProcessor {
    /**
     * 查询供应商
     * @param aGSProviderBean       供应商数据Bean对象
     * @return                      查询到的供应商封装对象
     * @throws GSException
     */
    public ResultProcess getProviderByOpt(GSProviderBean aGSProviderBean) throws GSException{
        ArrayList tRs = new ArrayList();
        ResultProcess tResultProcess = new ResultProcess();
        try{
            GSProviderDAO tGSProviderDAO = new GSProviderDAO();
            tRs = tGSProviderDAO.queryProviderByOpt(aGSProviderBean);
            tResultProcess.setResult(tRs);
        }catch(GSException e){
            throw e;
        }catch(Exception e){
            GSLogWriter.error(this,e.toString());
            throw new GSException(GSException.E10021,GSException.E10021_MSG);
        }
        return tResultProcess;
    }
    /**
     * 取得供应商明细信息
     * @param aGSProviderId         供应商编码
     * @return                      供应商Bean对象
     * @throws GSException
     */
    public GSProviderBean getProviderDetail(String aGSProviderId) throws GSException{
        GSProviderBean tGSProviderBean = new GSProviderBean();
        try{
            GSProviderDAO tGSProviderDAO = new GSProviderDAO();
            //执行查询
            tGSProviderBean = tGSProviderDAO.queryProvider(aGSProviderId);
            boolean isAudit = tGSProviderDAO.isAuditProvider(aGSProviderId);
            tGSProviderBean.setIs_audit(isAudit ? ConstDefine.STR_YES : ConstDefine.STR_NO);
        }catch(GSException e){
            throw e;
        }catch(Exception e){
            GSLogWriter.error(this,e.toString());
            throw new GSException(GSException.E10022,GSException.E10022_MSG);
        }
        return tGSProviderBean;
    }
    
    /**
     * 新增供应商记录
     * 
     *        
     */
    public static void addTask(GSProviderBean aGSProviderBean)throws GSException {
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        if (tGSProviderDAO.add(aGSProviderBean) == false) {
            throw new GSException("");
        }
    }
    
    /**
     * 删除供应商记录
     * 
     * @param aProviderId 供应商编号
     *            
     * throws CUPSException
     */
    public static void withdrawTask(GSProviderBean tGSProviderBean)throws GSException{
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        //删除组织机构信息
            if(tGSProviderDAO.delete(tGSProviderBean)==false){
                throw new GSException("");
            }
    }
    
    /**
     * 供应商是否有效
     * 
     * @param aProviderId 供应商编号
     *            
     * throws CUPSException
     */
    public static void setIsOkOrNot(GSProviderBean tGSProviderBean,String type)throws GSException{
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        //删除组织机构信息
            if(tGSProviderDAO.setIsOkOrNot(tGSProviderBean,type)==false){
                throw new GSException("");
            }
    }
    
    /**
     * 修改供应商记录
     * 
     * @param aMerchantTempBean
     *           
     * throws CUPSException
     */
    public static void modifyTask(GSProviderBean aGSProviderBean) throws GSException{
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        //修改机构信息
        if(tGSProviderDAO.modify(aGSProviderBean)==false){
            throw new GSException("");
        }
    }
    
    public GSProviderBean getProviderById(String providerId) throws GSException {
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        
        return tGSProviderDAO.queryProvider(providerId);
    }
    
    public GSProviderBean getProviderByShortName(String shortName) throws GSException {
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        
        return tGSProviderDAO.queryProviderByShortName(shortName);
        
    }
    public GSProviderBean getProviderByName(String Name) throws GSException {
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        
        return tGSProviderDAO.queryProviderByName(Name);
        
    }
    
    /** 
     * 增加供应商时:
     * 1:先查出最大编号
     * 2:占用最大编号
     * 备注:影响到新增供应商方法,在接下来进行新增动作的时候,应该是进行update动作
     * */
    public void setTempMaxProviderCode(String maxCode){
        GSProviderDAO tGSProviderDAO = new GSProviderDAO();
        try {
            tGSProviderDAO.engrossMaxCode(maxCode);
        } catch (GSException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 根据id或简称查询供应商信息
     * **/
    public GSProviderBean queryProviderByShortNameOrId(String tVal) throws GSException{
        GSProviderDAO tGSProviderDAO = new GSProviderDAO(); 
        return tGSProviderDAO.queryProviderByShortNameOrId(tVal);
    }
    
    /**
     * 新增、修改供应商审核类型
     * @param provider
     */
    public void updateProviderType(GSProviderBean provider, User loginUser) {
    	// TODO 由小潘接手
    	String tDelSql = "delete from t_provider where provider_code = ?";
    	String tInsSql = "insert into t_provider values ()";
    	
    	
    }
    
    /**
     * 修改供应商明细
     * 	若供应商为审核类，则将此供应商下所有产品设置为IV类，
     *  若供应商不为审核类，则将此供应商下所有设置为IV类产品的数据删除
     * @param aProvider
     * @param isAudit
     * @param loginContext
     * @throws GSException
     */
    public void modifyProvider(GSProviderBean aProvider, String isAudit, LoginContext loginContext) throws Exception {
    	Connection con = null;
    	
    	try {
    		GSProviderDAO tProviderDao = new GSProviderDAO();
    		GSProductTypeDao tProductTypeDao = new GSProductTypeDao();
    		
    		con = DBConnectionManager.getInstance().getConnection(); 
    		// 1. 修改供应商信息
    		tProviderDao.modify(con, aProvider);
    		// 2. 若供应商为审核类，在t_provider_type表中插入一条数据
//    		if(ConstDefine.STR_YES.equals(isAudit) && !tProviderDao.isAuditProvider(aProvider.getGs_provider_id())) {
//    			tProviderDao.insertProvierAuditType(con, aProvider, loginContext);
//    		} 
    		// 若供应商不为审核类，删除t_provider_type表中的对应数据
//    		if(ConstDefine.STR_NO.equals(isAudit) && tProviderDao.isAuditProvider(aProvider.getGs_provider_id())){
//    			tProviderDao.deleteProviderAuditType(con, aProvider.getGs_provider_id());
//    		}
    		
    		// 3. 若供应商为审核类，修改此供应商下所有产品类型信息，设置为IV类
//    		if(ConstDefine.STR_YES.equals(isAudit)) {
//    			tProductTypeDao.insetByProviderCode(aProvider.getGs_provider_id(), con, loginContext, GSBaseConstants.PRODUCT_TYPE4);
//    		} 
    		// 4. 若供应商不为审核类，则将此供应商下所有设置为IV类产品的类型数据逻辑删除
//    		else {
//    			tProductTypeDao.deleteByStatus(aProvider.getGs_provider_id(), con, GSBaseConstants.PRODUCT_TYPE4);
//    		}
    		
    		con.commit();
    	}  catch(Exception e) {
    		con.rollback();
    		GSLogWriter.error(e.getLocalizedMessage(), e);
    		throw e;
    	} finally {
    		if(con != null) {
    			con.close();
    		}
    	}
    }
    
    /**
     * 增加供应商明细
     * 若供应商为审核类，则将此供应商下所有产品设置为IV类，
     */
    public void addProvider(GSProviderBean aProvider, String isAudit, LoginContext loginContext) throws Exception {
    	Connection con = null;
    	
    	try {
    		GSProviderDAO tProviderDao = new GSProviderDAO();
    		GSProductTypeDao tProductTypeDao = new GSProductTypeDao();
    		
    		con = DBConnectionManager.getInstance().getConnection(); 
    		// 1. 修改供应商信息
    		tProviderDao.add(con, aProvider);
    		// 2. 若供应商为审核类，在t_provider_type表中插入一条数据
    		if(ConstDefine.STR_YES.equals(isAudit) && !tProviderDao.isAuditProvider(aProvider.getGs_provider_id())) {
    			tProviderDao.insertProvierAuditType(con, aProvider, loginContext);
    		}
    		
    		// 3. 若供应商为审核类，修改此供应商下所有产品类型信息，设置为IV类
    		if(ConstDefine.STR_YES.equals(isAudit)) {
    			tProductTypeDao.insetByProviderCode(aProvider.getGs_provider_id(), con, loginContext, GSBaseConstants.PRODUCT_TYPE4);
    		} 
    		// 4. 若供应商不为审核类，则将此供应商下所有设置为IV类产品的类型数据删除
    		else {
    			tProductTypeDao.delete(aProvider.getGs_provider_id(), con, GSBaseConstants.PRODUCT_TYPE4);
    		}
    		
    		con.commit();
    	}  catch(Exception e) {
    		con.rollback();
    		GSLogWriter.error(e.getLocalizedMessage(), e);
    		throw e;
    	} finally {
    		if(con != null) {
    			con.close();
    		}
    	}
    }
}
